// index.ts
// 获取应用实例
const app = getApp<IAppOption>()

// 定义方向枚举
enum Direction {
  UP,
  RIGHT,
  DOWN,
  LEFT
}

Component({
  data: {
    // 4x4网格，初始值为0表示空单元格
    grid: [
      [0, 0, 0, 0],
      [0, 0, 0, 0],
      [0, 0, 0, 0],
      [0, 0, 0, 0]
    ],
    touchStartX: 0,
    touchStartY: 0,
    isGameOver: false
  },
  lifetimes: {
    attached() {
      // 组件加载时开始新游戏
      this.startNewGame();
    }
  },
  methods: {
    // 开始新游戏
    startNewGame() {
      // 清空网格
      const emptyGrid = [
        [0, 0, 0, 0],
        [0, 0, 0, 0],
        [0, 0, 0, 0],
        [0, 0, 0, 0]
      ];
      
      this.setData({
        grid: emptyGrid,
        isGameOver: false
      }, () => {
        // 生成两个初始数字
        this.generateRandomNumber();
        this.generateRandomNumber();
      });
    },

    // 生成随机数字（2或4）并放置在空单元格中
    generateRandomNumber() {
      // 获取所有空单元格的位置
      const emptyCells: {row: number, col: number}[] = [];
      for (let i = 0; i < 4; i++) {
        for (let j = 0; j < 4; j++) {
          if (this.data.grid[i][j] === 0) {
            emptyCells.push({row: i, col: j});
          }
        }
      }
      
      // 如果没有空单元格，则返回
      if (emptyCells.length === 0) return;
      
      // 随机选择一个空单元格
      const randomIndex = Math.floor(Math.random() * emptyCells.length);
      const cell = emptyCells[randomIndex];
      
      // 生成数字2或4，2的概率为90%，4的概率为10%
      const value = Math.random() < 0.9 ? 2 : 4;
      
      // 更新网格
      const newGrid = [...this.data.grid];
      newGrid[cell.row][cell.col] = value;
      
      this.setData({
        grid: newGrid
      });
    },

    // 触摸开始事件
    handleTouchStart(e: WechatMiniprogram.TouchEvent) {
      if (this.data.isGameOver) return;
      
      const touch = e.touches[0];
      this.setData({
        touchStartX: touch.clientX,
        touchStartY: touch.clientY
      });
    },

    // 触摸结束事件
    handleTouchEnd(e: WechatMiniprogram.TouchEvent) {
      if (this.data.isGameOver) return;
      
      const touch = e.changedTouches[0];
      const deltaX = touch.clientX - this.data.touchStartX;
      const deltaY = touch.clientY - this.data.touchStartY;
      
      // 设置滑动阈值为10像素
      const minDistance = 10;
      
      // 判断滑动方向
      if (Math.abs(deltaX) > Math.abs(deltaY)) {
        // 水平滑动
        if (Math.abs(deltaX) > minDistance) {
          if (deltaX > 0) {
            // 右滑
            this.move(Direction.RIGHT);
          } else {
            // 左滑
            this.move(Direction.LEFT);
          }
        }
      } else {
        // 垂直滑动
        if (Math.abs(deltaY) > minDistance) {
          if (deltaY > 0) {
            // 下滑
            this.move(Direction.DOWN);
          } else {
            // 上滑
            this.move(Direction.UP);
          }
        }
      }
    },

    // 移动和合并操作
    move(direction: Direction) {
      // 复制当前网格状态，用于比较是否发生变化
      const oldGrid = JSON.stringify(this.data.grid);
      let newGrid = JSON.parse(oldGrid);
      
      // 根据方向执行移动和合并
      switch (direction) {
        case Direction.LEFT:
          newGrid = this.moveLeft(newGrid);
          break;
        case Direction.RIGHT:
          newGrid = this.moveRight(newGrid);
          break;
        case Direction.UP:
          newGrid = this.moveUp(newGrid);
          break;
        case Direction.DOWN:
          newGrid = this.moveDown(newGrid);
          break;
      }
      
      // 检查是否发生了变化
      const hasChanged = oldGrid !== JSON.stringify(newGrid);
      
      if (hasChanged) {
        // 更新网格
        this.setData({
          grid: newGrid
        }, () => {
          // 生成新数字
          this.generateRandomNumber();
          
          // 检查游戏是否结束
          if (this.isGameOver()) {
            this.setData({
              isGameOver: true
            });
            wx.showToast({
              title: '游戏结束',
              icon: 'none',
              duration: 2000
            });
          }
        });
      }
    },

    // 向左移动
    moveLeft(grid: number[][]) {
      const newGrid = [];
      
      // 处理每一行
      for (let i = 0; i < 4; i++) {
        // 获取当前行的非零数字
        const row = grid[i];
        let numbers = row.filter(n => n !== 0);
        
        // 合并相同的数字
        for (let j = 0; j < numbers.length - 1; j++) {
          if (numbers[j] === numbers[j + 1]) {
            numbers[j] *= 2;
            numbers[j + 1] = 0;
          }
        }
        
        // 再次过滤掉合并后产生的零
        numbers = numbers.filter(n => n !== 0);
        
        // 填充零
        while (numbers.length < 4) {
          numbers.push(0);
        }
        
        newGrid.push(numbers);
      }
      
      return newGrid;
    },

    // 向右移动
    moveRight(grid: number[][]) {
      const newGrid = [];
      
      // 处理每一行
      for (let i = 0; i < 4; i++) {
        // 获取当前行的非零数字
        const row = grid[i];
        let numbers = row.filter(n => n !== 0);
        
        // 合并相同的数字（从右向左）
        for (let j = numbers.length - 1; j > 0; j--) {
          if (numbers[j] === numbers[j - 1]) {
            numbers[j] *= 2;
            numbers[j - 1] = 0;
          }
        }
        
        // 再次过滤掉合并后产生的零
        numbers = numbers.filter(n => n !== 0);
        
        // 填充零（在左侧）
        while (numbers.length < 4) {
          numbers.unshift(0);
        }
        
        newGrid.push(numbers);
      }
      
      return newGrid;
    },

    // 向上移动
    moveUp(grid: number[][]) {
      // 转置网格
      let transposed = this.transposeGrid(grid);
      
      // 向左移动（转置后相当于向上）
      transposed = this.moveLeft(transposed);
      
      // 再次转置回原来的方向
      return this.transposeGrid(transposed);
    },

    // 向下移动
    moveDown(grid: number[][]) {
      // 转置网格
      let transposed = this.transposeGrid(grid);
      
      // 向右移动（转置后相当于向下）
      transposed = this.moveRight(transposed);
      
      // 再次转置回原来的方向
      return this.transposeGrid(transposed);
    },

    // 转置网格（行变列，列变行）
    transposeGrid(grid: number[][]) {
      const transposed = [];
      
      for (let i = 0; i < 4; i++) {
        transposed.push([]);
        for (let j = 0; j < 4; j++) {
          transposed[i].push(grid[j][i]);
        }
      }
      
      return transposed;
    },

    // 检查游戏是否结束
    isGameOver() {
      const grid = this.data.grid;
      
      // 检查是否有空单元格
      for (let i = 0; i < 4; i++) {
        for (let j = 0; j < 4; j++) {
          if (grid[i][j] === 0) {
            return false;
          }
        }
      }
      
      // 检查水平方向是否有可合并的相邻单元格
      for (let i = 0; i < 4; i++) {
        for (let j = 0; j < 3; j++) {
          if (grid[i][j] === grid[i][j + 1]) {
            return false;
          }
        }
      }
      
      // 检查垂直方向是否有可合并的相邻单元格
      for (let i = 0; i < 3; i++) {
        for (let j = 0; j < 4; j++) {
          if (grid[i][j] === grid[i + 1][j]) {
            return false;
          }
        }
      }
      
      // 没有空单元格且没有可合并的相邻单元格，游戏结束
      return true;
    }
  }
})